const express = require('express');
const Category = require('../models/Category');
const Product = require('../models/Product');
const MiniappImage = require('../models/MiniappImage');

const router = express.Router();

/**
 * 获取顶级分类列表（公开接口，无需鉴权）
 * GET /api/public/categories/top
 */
router.get('/categories/top', async (req, res) => {
  try {
    const categories = await Category.getTopLevel();

    // 只返回必要字段
    const result = categories.map(category => ({
      id: category.id,
      name: category.name,
      icon_url: category.icon_url,
      sort_order: category.sort_order
    }));

    res.success(result, '获取顶级分类成功');
  } catch (error) {
    console.error('获取顶级分类失败:', error);
    res.error('获取顶级分类失败', 500, error.message);
  }
});

/**
 * 获取商品列表（公开接口，无需鉴权）
 * GET /api/public/products
 * 查询参数：
 * - category_id: 分类ID（精确匹配）
 * - parent_category_id: 父分类ID（包含子分类）
 * - page: 页码，默认1
 * - pageSize: 每页数量，默认10
 * - search: 搜索关键词
 */
router.get('/products', async (req, res) => {
  try {
    const {
      category_id = null,
      parent_category_id = null,
      page = 1,
      pageSize = 10,
      search = ''
    } = req.query;

    // 强制只返回上架商品
    const result = await Product.getList({
      page: parseInt(page),
      pageSize: parseInt(pageSize),
      search,
      category_id: category_id ? parseInt(category_id) : null,
      parent_category_id: parent_category_id ? parseInt(parent_category_id) : null,
      status: 'active' // 强制只返回上架商品
    });

    // 只返回必要字段，保护敏感信息
    const products = result.products.map(product => ({
      id: product.id,
      name: product.name,
      price: product.price,
      main_image_url: product.main_image_url
    }));

    res.success({
      products,
      total: result.total
    }, '获取商品列表成功');

  } catch (error) {
    console.error('获取商品列表失败:', error);
    res.error('获取商品列表失败', 500, error.message);
  }
});

/**
 * 获取商品详情（公开接口，无需鉴权）
 * GET /api/public/products/:id
 */
router.get('/products/:id', async (req, res) => {
  try {
    const { id } = req.params;

    let product;
    try {
      product = await Product.getById(id);
    } catch (error) {
      // 处理商品不存在等业务异常
      if (error.message === '商品不存在') {
        return res.error('商品不存在或已下架', 404);
      }
      // 其他数据库或系统错误继续抛出
      throw error;
    }

    // 检查商品是否上架
    if (product.status !== 'active') {
      return res.error('商品不存在或已下架', 404);
    }

    // 只返回必要字段
    const result = {
      id: product.id,
      name: product.name,
      price: product.price,
      market_price: product.market_price,
      description: product.description,
      main_image_url: product.main_image_url,
      gallery_image_urls: product.gallery_image_urls,
      category_name: product.category_name
    };

    res.success(result, '获取商品详情成功');

  } catch (error) {
    console.error('获取商品详情失败:', error);
    res.error(error.message || '获取商品详情失败', 404);
  }
});



/**
 * 获取公开配置（白名单）
 * GET /api/public/configs?keys=contact_wechat_id,contact_wechat_qr_url,contact_tip_text
 */
router.get('/configs', async (req, res) => {
  try {
    const allowList = new Set(['contact_wechat_id', 'contact_wechat_qr_url', 'contact_tip_text']);
    const keys = (req.query.keys || '')
      .split(',')
      .map(k => k.trim())
      .filter(k => k && allowList.has(k));

    if (keys.length === 0) {
      return res.success({}, '无指定配置项');
    }

    const placeholders = keys.map(() => '?').join(',');
    const rows = await require('../config/db').query(
      `SELECT config_key, config_value FROM system_configs WHERE config_key IN (${placeholders})`,
      keys
    );

    const result = Object.fromEntries(keys.map(k => [k, null]));
    for (const r of rows) {
      result[r.config_key] = r.config_value;
    }

    // 默认值
    if (result.contact_wechat_id == null) result.contact_wechat_id = 'jewelry_store_2024';
    if (result.contact_wechat_qr_url == null) result.contact_wechat_qr_url = '/static/images/wechat-qr.jpg';
    if (result.contact_tip_text == null) result.contact_tip_text = '我们已记录您的选购信息，添加客服微信即可继续沟通付款';

    return res.success(result, '获取配置成功');
  } catch (error) {
    console.error('获取配置失败:', error);
    return res.error('获取配置失败', 500, error.message);
  }
});

/**
 * 获取小程序图片配置（公开接口）
 * GET /api/public/miniapp-images
 */
router.get('/miniapp-images', async (req, res) => {
  try {
    const { page_name } = req.query;

    if (page_name) {
      // 获取指定页面的图片配置
      const images = await MiniappImage.findByPageName(page_name);

      // 转换为键值对格式
      const result = {};
      images.forEach(image => {
        result[image.image_key] = {
          name: image.image_name,
          url: image.image_url,
          type: image.image_type,
          sort_order: image.sort_order
        };
      });

      res.success(result, '获取页面图片配置成功');
    } else {
      // 获取所有页面的图片配置
      const allImages = await MiniappImage.getAllForMiniapp();
      res.success(allImages, '获取所有图片配置成功');
    }
  } catch (error) {
    console.error('获取小程序图片配置失败:', error);
    res.error('获取图片配置失败', 500, error.message);
  }
});

/**
 * 根据图片键获取单个图片URL（公开接口）
 * GET /api/public/miniapp-images/:imageKey
 */
router.get('/miniapp-images/:imageKey', async (req, res) => {
  try {
    const { imageKey } = req.params;

    const image = await MiniappImage.findByKey(imageKey);

    if (!image || !image.is_active) {
      return res.error('图片配置不存在或已禁用', 404);
    }

    res.success({
      image_key: image.image_key,
      image_name: image.image_name,
      image_url: image.image_url,
      image_type: image.image_type,
      page_name: image.page_name
    }, '获取图片配置成功');
  } catch (error) {
    console.error('获取图片配置失败:', error);
    res.error('获取图片配置失败', 500, error.message);
  }
});

module.exports = router;
